const http = require('http');

// 全局变量存储测试数据
let gameId = '';
let playerId1 = '';
let playerId2 = '';

// 生成唯一的GUID
function generateGuid() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
    const r = Math.random() * 16 | 0;
    const v = c === 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });
}

// 发送HTTP请求的通用函数
function sendRequest(options, postData = null) {
  return new Promise((resolve, reject) => {
    const req = http.request(options, (res) => {
      let data = '';
      res.on('data', (chunk) => {
        data += chunk;
      });
      res.on('end', () => {
        resolve({ statusCode: res.statusCode, data });
      });
    });
    req.on('error', (e) => {
      reject(e);
    });
    if (postData) {
      req.write(postData);
    }
    req.end();
  });
}

// 测试创建游戏API
async function testCreateGame() {
  console.log('\n1. 测试创建游戏API...');
  const postData = JSON.stringify({
    Name: 'Integration Test Game',
    GridSize: 10,
    MaxPlayers: 4
  });

  const options = {
    hostname: 'localhost',
    port: 5258,
    path: '/api/Game',
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Content-Length': Buffer.byteLength(postData)
    }
  };

  try {
    const result = await sendRequest(options, postData);
    console.log(`  状态码: ${result.statusCode}`);
    console.log(`  响应: ${result.data}`);
    
    if (result.statusCode === 201) {
      // 修复游戏ID格式问题 - 移除可能的引号
      gameId = result.data.trim().replace(/"/g, '').replace(/'/g, '');
      console.log(`  ✅ 创建游戏成功，游戏ID: ${gameId}`);
      return true;
    } else {
      console.error('  ❌ 创建游戏失败');
      return false;
    }
  } catch (error) {
    console.error(`  ❌ 创建游戏API错误: ${error.message}`);
    return false;
  }
}

// 测试获取游戏详情API
async function testGetGame() {
  console.log('\n2. 测试获取游戏详情API...');
  if (!gameId) {
    console.error('  ❌ 游戏ID不存在，跳过测试');
    return false;
  }

  const options = {
    hostname: 'localhost',
    port: 5258,
    path: `/api/Game/${gameId}`,
    method: 'GET',
    headers: {
      'Content-Type': 'application/json'
    }
  };

  try {
    const result = await sendRequest(options);
    console.log(`  状态码: ${result.statusCode}`);
    console.log(`  响应: ${result.data}`);
    
    if (result.statusCode === 200) {
      console.log('  ✅ 获取游戏详情成功');
      return true;
    } else {
      console.error('  ❌ 获取游戏详情失败');
      return false;
    }
  } catch (error) {
    console.error(`  ❌ 获取游戏详情API错误: ${error.message}`);
    return false;
  }
}

// 测试获取所有活跃游戏API
async function testGetActiveGames() {
  console.log('\n3. 测试获取所有活跃游戏API...');

  const options = {
    hostname: 'localhost',
    port: 5258,
    path: '/api/Game',
    method: 'GET',
    headers: {
      'Content-Type': 'application/json'
    }
  };

  try {
    const result = await sendRequest(options);
    console.log(`  状态码: ${result.statusCode}`);
    
    // 解析JSON并打印游戏数量
    try {
      const games = JSON.parse(result.data);
      console.log(`  游戏总数: ${games.length}`);
      console.log('  ✅ 获取所有活跃游戏成功');
    } catch (e) {
      console.log(`  响应示例: ${result.data.substring(0, 200)}...`);
      console.error('  ❌ 解析游戏数据失败');
      return false;
    }
    
    return true;
  } catch (error) {
    console.error(`  ❌ 获取所有活跃游戏API错误: ${error.message}`);
    return false;
  }
}

// 测试加入游戏API
async function testJoinGame(playerName) {
  console.log(`\n4. 测试加入游戏API (玩家: ${playerName})...`);
  if (!gameId) {
    console.error('  ❌ 游戏ID不存在，跳过测试');
    return false;
  }

  const postData = JSON.stringify({
    PlayerName: playerName
  });

  const options = {
    hostname: 'localhost',
    port: 5258,
    path: `/api/Game/${gameId}/join`,
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Content-Length': Buffer.byteLength(postData)
    }
  };

  try {
    const result = await sendRequest(options, postData);
    console.log(`  状态码: ${result.statusCode}`);
    console.log(`  响应: ${result.data}`);
    
    if (result.statusCode === 200) {
      // 保存玩家ID并确保格式正确
      const rawPlayerId = result.data.trim();
      const id = rawPlayerId.replace(/"/g, '').replace(/'/g, '');
      console.log(`  ✅ 玩家加入游戏成功，玩家ID: ${id}`);
      return id;
    } else {
      console.error('  ❌ 玩家加入游戏失败');
      return null;
    }
  } catch (error) {
    console.error(`  ❌ 加入游戏API错误: ${error.message}`);
    return null;
  }
}

// 测试开始游戏API
async function testStartGame() {
  console.log('\n5. 测试开始游戏API...');
  if (!gameId || !playerId1) {
    console.error('  ❌ 游戏ID或玩家ID不存在，跳过测试');
    console.error(`  - gameId: ${gameId}`);
    console.error(`  - playerId1: ${playerId1}`);
    return false;
  }

  console.log(`  发送开始游戏请求 - GameId: ${gameId}, PlayerId: ${playerId1}`);
  
  // 修复请求格式，直接传递PlayerId
  const postData = JSON.stringify({
    "PlayerId": playerId1
  });
  
  console.log(`  请求数据: ${postData}`);

  const options = {
    hostname: 'localhost',
    port: 5258,
    path: `/api/Game/${gameId}/start`,
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Content-Length': Buffer.byteLength(postData)
    }
  };
  
  console.log(`  请求URL: http://${options.hostname}:${options.port}${options.path}`);

  try {
    console.log('  开始发送请求...');
    const result = await sendRequest(options, postData);
    console.log(`  状态码: ${result.statusCode}`);
    console.log(`  响应头: ${JSON.stringify(result.headers)}`);
    console.log(`  响应: ${result.data || '无内容(No Content)'}`);
    
    if (result.statusCode === 204) {
      console.log('  ✅ 开始游戏成功');
      
      // 立即检查游戏状态
      await checkGameStatus();
      return true;
    } else {
      console.error(`  ❌ 开始游戏失败，状态码: ${result.statusCode}`);
      return false;
    }
  } catch (error) {
    console.error(`  ❌ 开始游戏API错误: ${error.message}`);
    return false;
  }
}

// 检查游戏状态的辅助函数
async function checkGameStatus(returnGameObj = false) {
  console.log('\n检查游戏状态...');
  if (!gameId) {
    console.error('  ❌ 游戏ID不存在');
    return returnGameObj ? null : undefined;
  }

  const options = {
    hostname: 'localhost',
    port: 5258,
    path: `/api/Game/${gameId}`,
    method: 'GET',
    headers: {
      'Content-Type': 'application/json'
    }
  };

  try {
    const result = await sendRequest(options);
    if (result.statusCode === 200) {
      try {
        const game = JSON.parse(result.data);
        
        // 优先使用StatusName字段获取字符串形式的状态
        const status = game.statusName || game.status;
        console.log(`  游戏状态: ${status}`);
        console.log(`  玩家数量: ${game.players?.length || 0}`);
        console.log(`  开始时间: ${game.startedAt || '未开始'}`);
        
        // 如果需要返回游戏对象，确保status字段为字符串形式
        if (returnGameObj) {
          // 创建一个新对象，确保status为字符串
          const gameWithStringStatus = {
            ...game,
            status: status
          };
          return gameWithStringStatus;
        }
      } catch (e) {
        console.error('  ❌ 解析游戏数据失败');
        return returnGameObj ? null : undefined;
      }
    }
  } catch (error) {
    console.error(`  ❌ 检查游戏状态错误: ${error.message}`);
    return returnGameObj ? null : undefined;
  }
}

// 测试执行涂色操作API
async function testPaintAction() {
  console.log('\n6. 测试执行涂色操作API...');
  if (!gameId || !playerId1) {
    console.error('  ❌ 游戏ID或玩家ID不存在，跳过测试');
    return false;
  }

  // 在涂色操作前再次检查游戏状态
  console.log('  检查游戏状态是否为InProgress...');
  const gameStatus = await checkGameStatus(true); // true表示返回游戏状态对象
  if (!gameStatus || gameStatus.status !== 'InProgress') {
    console.error(`  ❌ 游戏当前状态: ${gameStatus?.status || '未知'}，无法执行涂色操作`);
    console.error('  涂色操作需要游戏处于InProgress状态');
    return false;
  }
  
  console.log('  ✅ 游戏状态正常，可以执行涂色操作');

  // 修复请求格式，直接传递参数
  const postData = JSON.stringify({
    "PlayerId": playerId1,
    "X": 0,
    "Y": 0
  });

  const options = {
    hostname: 'localhost',
    port: 5258,
    path: `/api/Game/${gameId}/paint`,
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Content-Length': Buffer.byteLength(postData)
    }
  };

  try {
    const result = await sendRequest(options, postData);
    console.log(`  状态码: ${result.statusCode}`);
    console.log(`  响应: ${result.data || '无内容(No Content)'}`);
    
    if (result.statusCode === 204) {
      console.log('  ✅ 执行涂色操作成功');
      return true;
    } else {
      console.error('  ❌ 执行涂色操作失败');
      return false;
    }
  } catch (error) {
    console.error(`  ❌ 执行涂色操作API错误: ${error.message}`);
    return false;
  }
}

// 测试离开游戏API - 接受玩家ID作为参数
async function testLeaveGame(playerId, playerName = 'Player') {
  console.log(`\n7. 测试离开游戏API (${playerName})...`);
  if (!gameId || !playerId) {
    console.error('  ❌ 游戏ID或玩家ID不存在，跳过测试');
    return false;
  }

  // 修复请求格式，直接传递PlayerId
  const postData = JSON.stringify({
    "PlayerId": playerId
  });

  const options = {
    hostname: 'localhost',
    port: 5258,
    path: `/api/Game/${gameId}/leave`,
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Content-Length': Buffer.byteLength(postData)
    }
  };

  try {
    const result = await sendRequest(options, postData);
    console.log(`  状态码: ${result.statusCode}`);
    console.log(`  响应: ${result.data || '无内容(No Content)'}`);
    
    if (result.statusCode === 204) {
      console.log('  ✅ 离开游戏成功');
      return true;
    } else {
      console.error('  ❌ 离开游戏失败');
      return false;
    }
  } catch (error) {
    console.error(`  ❌ 离开游戏API错误: ${error.message}`);
    return false;
  }
}

// 主测试函数
async function runAllTests() {
  console.log('开始测试所有后端API接口...');
  
  const results = [];
  
  // 1. 创建游戏
  results.push(await testCreateGame());
  
  // 2. 获取游戏详情
  results.push(await testGetGame());
  
  // 3. 获取所有活跃游戏
  results.push(await testGetActiveGames());
  
  // 4. 玩家1加入游戏
  const id1 = await testJoinGame('Player1');
  playerId1 = id1;
  results.push(!!id1);
  
  // 5. 玩家2加入游戏
  const id2 = await testJoinGame('Player2');
  playerId2 = id2;
  results.push(!!id2);
  
  // 6. 开始游戏 - 确保有两个玩家才能启动
  if (playerId1 && playerId2) {
    results.push(await testStartGame());
  } else {
    console.log('\n6. 测试开始游戏API...');
    console.log('  ⚠️  跳过开始游戏测试：需要至少2个玩家才能启动游戏');
    results.push(false);
  }
  
  // 7. 执行涂色操作 - 检查游戏是否已开始
  if (playerId1) {
    results.push(await testPaintAction());
  } else {
    results.push(false);
  }
  
  // 8. 玩家1离开游戏
  if (playerId1) {
    results.push(await testLeaveGame(playerId1, 'Player1'));
  } else {
    results.push(false);
  }
  
  // 9. 玩家2离开游戏
  if (playerId2) {
    results.push(await testLeaveGame(playerId2, 'Player2'));
  } else {
    results.push(false);
  }
  
  // 总结测试结果
  const passedCount = results.filter(result => result).length;
  console.log('\n=====================================');
  console.log(`测试总结: ${passedCount}/${results.length} 个测试通过`);
  
  if (passedCount === results.length) {
    console.log('✅ 所有API接口测试通过！');
  } else {
    console.log('❌ 部分API接口测试失败，请查看详细信息。');
  }
  console.log('=====================================');
}

// 启动测试
runAllTests().catch(err => {
  console.error('测试运行失败:', err);
});